home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / hplip / base / logger.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-10-28  |  15KB  |  462 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import thread
  6. import syslog
  7. import traceback
  8. import string
  9. import os
  10. import re
  11. import pprint
  12. identity = string.maketrans('', '')
  13. unprintable = identity.translate(identity, string.printable)
  14.  
  15. def printable(s):
  16.     return s.translate(identity, unprintable)
  17.  
  18. DEFAULT_LOG_LEVEL = 'info'
  19.  
  20. class Logger(object):
  21.     LOG_LEVEL_NONE = 99
  22.     LOG_LEVEL_FATAL = 40
  23.     LOG_LEVEL_ERROR = 30
  24.     LOG_LEVEL_WARN = 20
  25.     LOG_LEVEL_INFO = 10
  26.     LOG_LEVEL_DEBUG3 = 3
  27.     LOG_LEVEL_DBG3 = 3
  28.     LOG_LEVEL_DEBUG2 = 2
  29.     LOG_LEVEL_DBG2 = 2
  30.     LOG_LEVEL_DEBUG = 1
  31.     LOG_LEVEL_DBG = 1
  32.     logging_levels = {
  33.         'none': LOG_LEVEL_NONE,
  34.         'fata': LOG_LEVEL_FATAL,
  35.         'fatal': LOG_LEVEL_FATAL,
  36.         'erro': LOG_LEVEL_ERROR,
  37.         'error': LOG_LEVEL_ERROR,
  38.         'warn': LOG_LEVEL_WARN,
  39.         'info': LOG_LEVEL_INFO,
  40.         'debug': LOG_LEVEL_DEBUG,
  41.         'dbg': LOG_LEVEL_DEBUG,
  42.         'debug2': LOG_LEVEL_DEBUG2,
  43.         'dbg2': LOG_LEVEL_DEBUG2,
  44.         'debug3': LOG_LEVEL_DEBUG3,
  45.         'dbg3': LOG_LEVEL_DEBUG3 }
  46.     LOG_TO_DEV_NULL = 0
  47.     LOG_TO_CONSOLE = 1
  48.     LOG_TO_SCREEN = 1
  49.     LOG_TO_FILE = 2
  50.     LOG_TO_CONSOLE_AND_FILE = 3
  51.     LOG_TO_BOTH = 3
  52.     codes = { }
  53.     codes['reset'] = '\x1b[0m'
  54.     codes['bold'] = '\x1b[01m'
  55.     codes['teal'] = '\x1b[36;06m'
  56.     codes['turquoise'] = '\x1b[36;01m'
  57.     codes['fuscia'] = '\x1b[35;01m'
  58.     codes['purple'] = '\x1b[35;06m'
  59.     codes['blue'] = '\x1b[34;01m'
  60.     codes['darkblue'] = '\x1b[34;06m'
  61.     codes['green'] = '\x1b[32;01m'
  62.     codes['darkgreen'] = '\x1b[32;06m'
  63.     codes['yellow'] = '\x1b[33;01m'
  64.     codes['brown'] = '\x1b[33;06m'
  65.     codes['red'] = '\x1b[31;01m'
  66.     codes['darkred'] = '\x1b[31;06m'
  67.     
  68.     def __init__(self, module = '', level = LOG_LEVEL_INFO, where = LOG_TO_CONSOLE_AND_FILE, log_datetime = False, log_file = None):
  69.         self._where = where
  70.         self._log_file = log_file
  71.         self._log_file_f = None
  72.         self._log_datetime = log_datetime
  73.         self._lock = thread.allocate_lock()
  74.         self.module = module
  75.         self.pid = os.getpid()
  76.         self.fmt = True
  77.         self.set_level(level)
  78.  
  79.     
  80.     def set_level(self, level):
  81.         if isinstance(level, str):
  82.             level = level.lower()
  83.             if level in Logger.logging_levels.keys():
  84.                 self._level = Logger.logging_levels.get(level, Logger.LOG_LEVEL_INFO)
  85.                 return True
  86.             self.error('Invalid logging level: %s' % level)
  87.             return False
  88.         isinstance(level, str)
  89.         if isinstance(level, int):
  90.             if level <= level:
  91.                 pass
  92.             elif level <= Logger.LOG_LEVEL_FATAL:
  93.                 self._level = level
  94.             else:
  95.                 self._level = Logger.LOG_LEVEL_ERROR
  96.                 self.error('Invalid logging level: %d' % level)
  97.                 return False
  98.         level <= Logger.LOG_LEVEL_FATAL
  99.         return False
  100.  
  101.     
  102.     def set_module(self, module):
  103.         self.module = module
  104.         self.pid = os.getpid()
  105.  
  106.     
  107.     def no_formatting(self):
  108.         self.fmt = False
  109.  
  110.     
  111.     def set_logfile(self, log_file):
  112.         self._log_file = log_file
  113.         
  114.         try:
  115.             self._log_file_f = file(self._log_file, 'w')
  116.         except IOError:
  117.             self._log_file = None
  118.             self._log_file_f = None
  119.             self._where = Logger.LOG_TO_SCREEN
  120.  
  121.  
  122.     
  123.     def get_logfile(self):
  124.         return self._log_file
  125.  
  126.     
  127.     def set_where(self, where):
  128.         self._where = where
  129.  
  130.     
  131.     def get_level(self):
  132.         return self._level
  133.  
  134.     
  135.     def is_debug(self):
  136.         return self._level <= Logger.LOG_LEVEL_DEBUG3
  137.  
  138.     level = property(get_level, set_level)
  139.     
  140.     def log(self, message, level, newline = True):
  141.         if self._level <= level:
  142.             if self._where in (Logger.LOG_TO_CONSOLE, Logger.LOG_TO_CONSOLE_AND_FILE):
  143.                 
  144.                 try:
  145.                     self._lock.acquire()
  146.                     if level >= Logger.LOG_LEVEL_WARN:
  147.                         out = sys.stderr
  148.                     else:
  149.                         out = sys.stdout
  150.                     
  151.                     try:
  152.                         out.write(message)
  153.                     except UnicodeEncodeError:
  154.                         out.write(message.encode('utf-8'))
  155.  
  156.                     if newline:
  157.                         out.write('\n')
  158.                 finally:
  159.                     self._lock.release()
  160.  
  161.             
  162.         
  163.  
  164.     
  165.     def log_to_file(self, message):
  166.         if self._log_file_f is not None:
  167.             
  168.             try:
  169.                 self._lock.acquire()
  170.                 self._log_file_f.write(message.replace('\x1b', ''))
  171.                 self._log_file_f.write('\n')
  172.             finally:
  173.                 self._lock.release()
  174.  
  175.         
  176.  
  177.     
  178.     def stderr(self, message):
  179.         
  180.         try:
  181.             self._lock.acquire()
  182.             sys.stderr.write('%s: %s\n' % (self.module, message))
  183.         finally:
  184.             self._lock.release()
  185.  
  186.  
  187.     
  188.     def debug(self, message):
  189.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  190.             txt = '%s[%d]: debug: %s' % (self.module, self.pid, message)
  191.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG)
  192.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  193.                 self.log_to_file(txt)
  194.             
  195.         
  196.  
  197.     dbg = debug
  198.     
  199.     def debug2(self, message):
  200.         if self._level <= Logger.LOG_LEVEL_DEBUG2:
  201.             txt = '%s[%d]: debug2: %s' % (self.module, self.pid, message)
  202.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG2)
  203.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  204.                 self.log_to_file(txt)
  205.             
  206.         
  207.  
  208.     dbg2 = debug2
  209.     
  210.     def debug3(self, message):
  211.         if self._level <= Logger.LOG_LEVEL_DEBUG3:
  212.             txt = '%s[%d]: debug3: %s' % (self.module, self.pid, message)
  213.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG3)
  214.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  215.                 self.log_to_file(txt)
  216.             
  217.         
  218.  
  219.     dbg3 = debug3
  220.     
  221.     def debug_block(self, title, block):
  222.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  223.             line = '%s[%d]: debug: %s:' % (self.module, self.pid, title)
  224.             self.log(self.color(line, 'blue'), Logger.LOG_LEVEL_DEBUG)
  225.             self.log(self.color(block, 'blue'), Logger.LOG_LEVEL_DEBUG)
  226.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  227.                 self.log_to_file(line % (self.module, self.pid, title))
  228.                 self.log_to_file(block)
  229.             
  230.         
  231.  
  232.     printable = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~  '
  233.     
  234.     def log_data(self, data, width = 16):
  235.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  236.             if data:
  237.                 index = 0
  238.                 line = data[0:width]
  239.                 for d in line:
  240.                     continue
  241.                     txt = _[1](_[1]['%02x' % ord(d)])([
  242.                         ' ' * (width * 3 - 3 * len(line)),
  243.                         ''.join,
  244.                         [],
  245.                         []([ ('.', i)[i in Logger.printable] for i in line ])])
  246.                     self.log(self.color('%s[%d]: debug: %s' % (self.module, self.pid, txt), 'blue'), Logger.LOG_LEVEL_DEBUG)
  247.                     index += width
  248.                     line = data[index:index + width]
  249.                     continue
  250.                     []
  251.             else:
  252.                 self.log(self.color('%s[%d]: debug: %s' % (self.module, self.pid, '0000: (no data)'), 'blue'), Logger.LOG_LEVEL_DEBUG)
  253.         
  254.  
  255.     
  256.     def info(self, message = ''):
  257.         if self._level <= Logger.LOG_LEVEL_INFO:
  258.             self.log(message, Logger.LOG_LEVEL_INFO)
  259.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  260.                 self.log_to_file('%s[%d]: info: :%s' % (self.module, self.pid, message))
  261.             
  262.         
  263.  
  264.     information = info
  265.     
  266.     def warn(self, message):
  267.         if self._level <= Logger.LOG_LEVEL_WARN:
  268.             txt = 'warning: %s' % message.encode('utf-8')
  269.             self.log(self.color(txt, 'fuscia'), Logger.LOG_LEVEL_WARN)
  270.             syslog.syslog(syslog.LOG_WARNING, '%s[%d]: %s' % (self.module, self.pid, txt))
  271.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  272.                 self.log_to_file(txt)
  273.             
  274.         
  275.  
  276.     warning = warn
  277.     
  278.     def note(self, message):
  279.         if self._level <= Logger.LOG_LEVEL_WARN:
  280.             txt = 'note: %s' % message
  281.             self.log(self.color(txt, 'green'), Logger.LOG_LEVEL_WARN)
  282.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  283.                 self.log_to_file(txt)
  284.             
  285.         
  286.  
  287.     notice = note
  288.     
  289.     def error(self, message):
  290.         if self._level <= Logger.LOG_LEVEL_ERROR:
  291.             txt = 'error: %s' % message.encode('utf-8')
  292.             self.log(self.color(txt, 'red'), Logger.LOG_LEVEL_ERROR)
  293.             syslog.syslog(syslog.LOG_ALERT, '%s[%d]: %s' % (self.module, self.pid, txt))
  294.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  295.                 self.log_to_file(txt)
  296.             
  297.         
  298.  
  299.     
  300.     def fatal(self, message):
  301.         if self._level <= Logger.LOG_LEVEL_FATAL:
  302.             txt = 'fatal error: :%s' % self.module.encode('utf-8')
  303.             self.log(self.color(txt, 'red'), Logger.LOG_LEVEL_DEBUG)
  304.             syslog.syslog(syslog.LOG_ALERT, '%s[%d]: %s' % (self.module, self.pid, txt))
  305.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  306.                 self.log_to_file(txt)
  307.             
  308.         
  309.  
  310.     
  311.     def exception(self):
  312.         (typ, value, tb) = sys.exc_info()
  313.         body = 'Traceback (innermost last):\n'
  314.         lst = traceback.format_tb(tb) + traceback.format_exception_only(typ, value)
  315.         body = body + '%-20s %s' % (''.join(lst[:-1]), lst[-1])
  316.         self.fatal(body)
  317.  
  318.     
  319.     def color(self, text, color):
  320.         if self.fmt:
  321.             return ''.join([
  322.                 Logger.codes.get(color, 'bold'),
  323.                 text,
  324.                 Logger.codes['reset']])
  325.         return text
  326.  
  327.     
  328.     def bold(self, text):
  329.         return self.color(text, 'bold')
  330.  
  331.     
  332.     def red(self, text):
  333.         return self.color(text, 'red')
  334.  
  335.     
  336.     def green(self, text):
  337.         return self.color(text, 'green')
  338.  
  339.     
  340.     def purple(self, text):
  341.         return self.color(text, 'purple')
  342.  
  343.     
  344.     def yellow(self, text):
  345.         return self.color(text, 'yellow')
  346.  
  347.     
  348.     def darkgreen(self, text):
  349.         return self.color(text, 'darkgreen')
  350.  
  351.     
  352.     def blue(self, text):
  353.         return self.color(text, 'blue')
  354.  
  355.     
  356.     def _pprint_line(self, indent_level, line, width = 100, level = LOG_LEVEL_DEBUG):
  357.         if line.strip():
  358.             start = ''
  359.             number_chars = 0
  360.             for l in range(indent_level):
  361.                 start = start + ' '
  362.                 number_chars = number_chars + 1
  363.             
  364.             
  365.             try:
  366.                 elem_start = re.findall('(\\<\\W{0,1}\\w+) ?', line)[0]
  367.                 elem_finished = re.findall('([?|\\]\\]]*\\>)', line)[0]
  368.                 attrs = re.findall('(\\S*?\\=".*?")', line)
  369.                 self.log(start + elem_start, level, False)
  370.                 number_chars = len(start + elem_start)
  371.                 for attr in attrs:
  372.                     if attrs.index(attr) + 1 == len(attrs):
  373.                         number_chars = number_chars + len(elem_finished)
  374.                     
  375.                     if number_chars + len(attr) + 1 > width:
  376.                         self.log('\n', level, False)
  377.                         self.log(' ' * (len(start + elem_start) + 1), level, False)
  378.                         number_chars = len(start + elem_start) + 1
  379.                     else:
  380.                         self.log(' ', level, False)
  381.                         number_chars = number_chars + 1
  382.                     self.log(attr, level, False)
  383.                     number_chars = number_chars + len(attr)
  384.                 
  385.                 self.log(elem_finished + '\n', level, False)
  386.             except IndexError:
  387.                 self.log(start + line + '\n', level, False)
  388.             except:
  389.                 None<EXCEPTION MATCH>IndexError
  390.             
  391.  
  392.         None<EXCEPTION MATCH>IndexError
  393.  
  394.     
  395.     def _pprint_elem_content(self, indent_level, line, level = LOG_LEVEL_DEBUG):
  396.         if line.strip():
  397.             self.log(' ' * indent_level, level, False)
  398.             self.log(line + '\n', level, False)
  399.         
  400.  
  401.     
  402.     def _get_next_elem(self, data):
  403.         start_pos = data.find('<')
  404.         end_pos = data.find('>') + 1
  405.         retval = data[start_pos:end_pos]
  406.         stopper = retval.rfind('/')
  407.         if stopper < retval.rfind('"'):
  408.             stopper = -1
  409.         
  410.         if stopper > -1:
  411.             pass
  412.         single = retval.find('>') - stopper < stopper - retval.find('<')
  413.         ignore_excl = retval.find('<!') > -1
  414.         ignore_question = retval.find('<?') > -1
  415.         if ignore_excl:
  416.             cdata = retval.find('<![CDATA[') > -1
  417.             if cdata:
  418.                 end_pos = data.find(']]>')
  419.                 if end_pos > -1:
  420.                     end_pos = end_pos + len(']]>')
  421.                 
  422.             
  423.         elif ignore_question:
  424.             end_pos = data.find('?>') + len('?>')
  425.         
  426.         if not ignore_excl:
  427.             pass
  428.         ignore = ignore_question
  429.         if not ignore:
  430.             pass
  431.         no_indent = single
  432.         return (start_pos, end_pos, stopper > -1, no_indent)
  433.  
  434.     
  435.     def xml(self, xml, level = LOG_LEVEL_DEBUG, indent = 4, width = 80):
  436.         '''Pretty print xml.
  437.         Use indent to select indentation level. Default is 4   '''
  438.         data = xml
  439.         indent_level = 0
  440.         (start_pos, end_pos, is_stop, no_indent) = self._get_next_elem(data)
  441.         while start_pos > -1 and end_pos > -1:
  442.             self._pprint_elem_content(indent_level, data[:start_pos].strip(), level = level)
  443.             data = data[start_pos:]
  444.             if is_stop and not no_indent:
  445.                 indent_level = indent_level - indent
  446.             
  447.             self._pprint_line(indent_level, data[:end_pos - start_pos], width = width, level = level)
  448.             data = data[end_pos - start_pos:]
  449.             if not is_stop and not no_indent:
  450.                 indent_level = indent_level + indent
  451.             
  452.             if not data:
  453.                 break
  454.                 continue
  455.             (start_pos, end_pos, is_stop, no_indent) = self._get_next_elem(data)
  456.  
  457.     
  458.     def pprint(self, data):
  459.         self.info(pprint.pformat(data))
  460.  
  461.  
  462.